//////////////#include<iostream>
//////////////#include<bitset>
//////////////#include<vector>
//////////////#include<string>
//////////////#include<set>
//////////////#include<map>
//////////////#include<string>
//////////////#include<assert.h>
//////////////using namespace std;
////////////////void f(int&& x)
////////////////{
////////////////	cout << "f" << endl;
////////////////}
////////////////void fun(int&& x)
////////////////{
////////////////	cout << "func" << endl;
////////////////	f(std::forward<int>(x));
////////////////}
////////////////int main()
////////////////{
////////////////	int a = 0;
////////////////	fun(1);
////////////////	int&& rr = 10;
////////////////	cout << typeid(rr).name() << endl;
////////////////	return 0;
////////////////}
////////////////class Solution {
////////////////public:
////////////////    vector<int> intersection(vector<int>& nums1, vector<int>& nums2)
////////////////    {
////////////////        vector<int> v;
////////////////        Solution::a = 1;
////////////////        bitset<1000> s;
////////////////        for (auto e : nums1)
////////////////            s.set(e);
////////////////        bitset<1000> a;
////////////////        for (auto e : nums2)
////////////////            a.set(e);
////////////////        auto t = s & a;
////////////////        for (size_t i = 0; i <= 1000; i++)
////////////////        {
////////////////            if (i < 1000 && t.test(i) == true)
////////////////                v.push_back(i);
////////////////        }
////////////////        return v;
////////////////    }
////////////////private:
////////////////    static int a;
////////////////};
////////////////int Solution::a = 0;
////////////////int main()
////////////////{
////////////////    vector<int> v = { 1,2,3,4 };
////////////////    vector<int> s = { 2,3,4 };
////////////////    Solution c;
////////////////    c.intersection(v, s);
////////////////    Solution b;
////////////////    b.intersection(v, s);
////////////////    return 0;
////////////////}
////////////////class Solution {
////////////////public:
////////////////    string removeDuplicateLetters(string s)
////////////////    {
////////////////        map<char, int> m;
////////////////        for (auto& e : s)
////////////////            m[e]++;
////////////////        string a;
////////////////        for (auto& e : m)
////////////////            a += e.first;
////////////////        return a;
////////////////    }
////////////////};
////////////////int main()
////////////////{
////////////////    string s = "abbbbbc";
////////////////    Solution().removeDuplicateLetters(s);
////////////////    return 0;
////////////////}
//////////////
////////////// struct ListNode {
//////////////     int val;
//////////////    ListNode *next;
//////////////     ListNode() : val(0), next(nullptr) {}
//////////////     ListNode(int x) : val(x), next(nullptr) {}
//////////////     ListNode(int x, ListNode *next) : val(x), next(next) {}
////////////// };
////////////// 
////////////// 
//////////////   struct TreeNode {
//////////////       int val;
//////////////       TreeNode *left;
//////////////       TreeNode *right;
//////////////       TreeNode() : val(0), left(nullptr), right(nullptr) {}
//////////////       TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
//////////////       TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
//////////////   };
//////////////  
//////////////class Solution {
//////////////public:
//////////////    void reol(TreeNode* parent, vector<TreeNode*>& s)
//////////////    {
//////////////        TreeNode* sub = parent->right;
//////////////        TreeNode* subl = sub->left;
//////////////        size_t i = 0;
//////////////        for (i = 0; i < s.size(); i++)
//////////////        {
//////////////            if (s[i] == parent)
//////////////                break;
//////////////        }
//////////////        if (_root == parent)
//////////////        {
//////////////            _root = sub;
//////////////            sub->left = parent;
//////////////            parent->right = subl;
//////////////        }
//////////////        else
//////////////        {
//////////////            TreeNode* pparent = s[i - 1];
//////////////            if (pparent->left == parent)
//////////////                pparent->left = sub;
//////////////            else
//////////////                pparent->right = sub;
//////////////            sub->left = parent;
//////////////            parent->right = subl;
//////////////        }
//////////////    }
//////////////    void reor(TreeNode* parent, vector<TreeNode*>& s)
//////////////    {
//////////////        TreeNode* sub = parent->left;
//////////////        TreeNode* subr = sub->right;
//////////////        size_t i = 0;
//////////////        for (i = 0; i < s.size(); i++)
//////////////        {
//////////////            if (s[i] == parent)
//////////////                break;
//////////////        }
//////////////        if (_root == parent)
//////////////        {
//////////////            _root = sub;
//////////////            sub->right = parent;
//////////////            parent->left = subr;
//////////////        }
//////////////        else
//////////////        {
//////////////            TreeNode* pparent = s[i - 1];
//////////////            if (pparent->left == parent)
//////////////                pparent->left = sub;
//////////////            else
//////////////                pparent->right = sub;
//////////////            sub->right = parent;
//////////////            parent->left = subr;
//////////////        }
//////////////    }
//////////////    bool creat(const int& x)
//////////////    {
//////////////        if (_root == nullptr)
//////////////        {
//////////////            _root = new TreeNode(x);
//////////////            return true;
//////////////        }
//////////////        vector<TreeNode*> s;
//////////////        TreeNode* parent = nullptr;
//////////////        TreeNode* cur = _root;
//////////////        while (cur)
//////////////        {
//////////////            parent = cur;
//////////////            if (x > cur->val)
//////////////                cur = cur->right;
//////////////            else if (x < cur->val)
//////////////                cur = cur->left;
//////////////            else
//////////////                return false;
//////////////            s.push_back(parent);
//////////////        }
//////////////        cur = new TreeNode(x);
//////////////        if (x < parent->val)
//////////////            parent->left = cur;
//////////////        else
//////////////            parent->right = cur;
//////////////        size_t ret = s.size() - 1;
//////////////        while (ret >= 0)
//////////////        {
//////////////            if (abs(bf(parent)) == 0)
//////////////                break;
//////////////            else if (abs(bf(parent)) == 1)
//////////////            {
//////////////                cur = parent;
//////////////                if (ret != 0)
//////////////                    parent = s[--ret];
//////////////                else
//////////////                    break;
//////////////            }
//////////////            else if (abs(bf(parent)) == 2)
//////////////            {
//////////////                if (bf(parent) == 2 && bf(cur) == 1)
//////////////                    reol(parent, s);
//////////////                else if (bf(parent) == 2 && bf(cur) == -1)
//////////////                {
//////////////                    reor(cur, s);
//////////////                    reol(parent, s);
//////////////                }
//////////////                else if (bf(parent) == -2 && bf(cur) == -1)
//////////////                    reor(parent, s);
//////////////                else if (bf(parent) == -2 && bf(cur) == 1)
//////////////                {
//////////////                    reol(cur, s);
//////////////                    reor(parent, s);
//////////////                }
//////////////                break;
//////////////            }
//////////////            else
//////////////                assert(false);
//////////////        }
//////////////        return true;
//////////////    }
//////////////    int high(TreeNode* root)
//////////////    {
//////////////        if (root == nullptr)
//////////////            return 0;
//////////////        int left = high(root->left);
//////////////        int right = high(root->right);
//////////////        return left > right ? left + 1 : right + 1;
//////////////    }
//////////////    int bf(TreeNode* root)
//////////////    {
//////////////        if (root == nullptr)
//////////////            return 0;
//////////////        int left = high(root->left);
//////////////        int right = high(root->right);
//////////////        return right - left;
//////////////    }
//////////////    TreeNode* sortedListToBST(ListNode* head)
//////////////    {
//////////////        if (head == nullptr)
//////////////            return nullptr;
//////////////        vector<int> v;
//////////////        while (head)
//////////////        {
//////////////            v.push_back(head->val);
//////////////            head = head->next;
//////////////        }
//////////////        for (auto e : v)
//////////////        {
//////////////             if (creat(e));
//////////////            else
//////////////                assert(false);
//////////////        }
//////////////        return _root;
//////////////    }
//////////////private:
//////////////    TreeNode* _root = nullptr;
//////////////};
//////////////int main()
//////////////{
//////////////    ListNode* head = nullptr;
//////////////    head = new ListNode(0);
//////////////    head->next = new ListNode(1);
//////////////    head->next->next = new ListNode(2);
//////////////    head->next->next->next = new ListNode(3);
//////////////    head->next->next->next->next = new ListNode(4);
//////////////    head->next->next->next->next->next = new ListNode(5);
//////////////    head->next->next->next->next->next->next = new ListNode(6);
//////////////    head->next->next->next->next->next->next->next = new ListNode(7);
//////////////    head->next->next->next->next->next->next->next->next = new ListNode(8);
//////////////    head->next->next->next->next->next->next->next->next->next = new ListNode(9);
//////////////
//////////////    TreeNode* root= Solution().sortedListToBST(head);
//////////////
//////////////
//////////////
//////////////
//////////////    return 0;
//////////////}
////////////#define _CRT_SECURE_NO_WARNINGS 1
////////////#include<iostream>
////////////#include<map>
////////////#include<set>
////////////#include<vector>
////////////#include<bitset>
////////////using namespace std;
//////////////class preson
//////////////{
//////////////public:
//////////////	preson(const int& x = int())
//////////////		:id(x)
//////////////	{}
//////////////private:
//////////////	int id = 0;
//////////////};
//////////////void func()
//////////////{
//////////////	try
//////////////	{
//////////////		const preson* p = new preson[1000000];
//////////////	}
//////////////	catch (...)
//////////////	{
//////////////		cout << "yichang " << endl;
//////////////	}
//////////////
//////////////}
//////////////int main()
//////////////{
//////////////	//func();
//////////////	return 0;
//////////////}
//////////////class Solution {
//////////////public:
//////////////    int rangeBitwiseAnd(int left, int right)
//////////////    {
//////////////        size_t N = -1;
//////////////        bitset<-1> s;
//////////////        while (left <= right)
//////////////            s.set(left++);
//////////////        size_t i = 0;
//////////////        int sum = 0;
//////////////        for (i = 0; i < N; i++)
//////////////        {
//////////////            if (i == 0 && s.test(i) == true)
//////////////                sum = sum | i;
//////////////            else if (s.test(i) == true)
//////////////                sum = sum & i;
//////////////        }
//////////////        return sum;
//////////////    }
//////////////};
//////////////int main()
//////////////{
//////////////    int ret = 5 & 6 & 7;
//////////////    Solution().rangeBitwiseAnd(5, 7);
//////////////    return 0;
//////////////}
////////////namespace cc
////////////{
////////////	class date
////////////	{
////////////		friend ostream& operator<<(ostream& out,const date& s);
////////////	public:
////////////		date(int x, int y, int z)
////////////			:day(x)
////////////			, year(y)
////////////			, month(z)
////////////		{}
////////////	private:
////////////		int day;
////////////		int year;
////////////		int month;
////////////	};
////////////	ostream& operator<<(ostream& out,const date& s)
////////////	{
////////////		out << s.day << s.year << s.month << endl;
////////////		return out;
////////////	}
////////////}
//////////////#include<string>
//////////////#include<stdio.h>
//////////////#include<algorithm>
//////////////#include<string.h>
//////////////int main()
//////////////{
//////////////	string s;
//////////////	char ch=0;
//////////////	for (; ch != '\n';)
//////////////	{
//////////////		cin.get(ch);
//////////////		s += ch;
//////////////	}
//////////////	reverse(s.begin(), s.end());
//////////////	cout << s;
//////////////	return 0;
//////////////}
////////////#include <iostream>
////////////#include<string>
////////////#include<algorithm>
////////////using namespace std;
////////////
////////////int main()
////////////{
////////////	int i = 5;
////////////	int const* p = &i; 
////////////	i = 6;
////////////	cout << (*p);
////////////   /* string s;
////////////    char ch = 0;
////////////    for (; ch != '\n';)
////////////    {
////////////        cin.get(ch);
////////////        s += ch;
////////////    }
////////////    reverse(s.begin(), s.end()-1);
////////////    string a;
////////////	string str;
////////////    for (auto e : s)
////////////    {
////////////		if (e == ' ')
////////////		{
////////////			reverse(str.begin(),str.end());
////////////			a += str;
////////////			a += e;
////////////			str.clear();
////////////		}
////////////		else
////////////			str += e;
////////////    }
////////////	reverse(str.begin(), str.end()-1);
////////////	a += str;
////////////    cout << a;*/
////////////}
////////////#include<iostream>
////////////using namespace std;
////////////void func()throw()
////////////{
////////////	int* p = new int(2);
////////////
////////////}
////////////int main()
////////////{
////////////	func();
////////////	return 0;
////////////}
//////////#include<iostream>
//////////using namespace std;
////////////class B
////////////{
////////////protected:
////////////	int a;
////////////	int b;
////////////};
////////////class C :public B
////////////{
////////////private:
////////////	int c;
////////////};
//////////class C
//////////{
//////////private:
//////////	int a;
//////////	int b;
//////////	int c;
//////////};
//////////int main()
//////////{
//////////	cout << sizeof(C) << endl;
//////////	return 0;
//////////}
////////#include<iostream>
////////#include<string>
////////#include<algorithm>
////////using namespace std;
////////int func()noexcept
////////{
////////	int i, j, k = 0;
////////	for (i = 0, j = -1; j == 0; i++, j++)
////////		k++;
////////	return k;
////////}
////////class Solution {
////////public:
////////    string reverseWords(string s)
////////    {
////////        reverse(s.begin(), s.end());
////////        string a;
////////        string tem;
////////        for (auto& e : s)
////////        {
////////            if (e != ' ')
////////                tem += e;
////////            else
////////            {
////////                reverse(tem.begin(), tem.end());
////////                tem += e;
////////                a += tem;
////////                tem.clear();
////////            }
////////        }
////////        reverse(tem.begin(), tem.end());
////////        a += tem;
////////        return a;
////////    }
////////};
////////int main()
////////{
////////    string s = "the sky is blue";
////////    Solution().reverseWords(s);
////////	return 0;
////////}
////////#include <iostream>
////////#include <vector>
////////#include <algorithm>
////////using namespace std;
////////
////////int main()
////////{
////////    int n = 0;
////////    cin >> n;
////////    vector<int> v;
////////    v.resize(n, 0);
////////    for (int i = 0; i < n; i++)
////////        cin >> v[i];
////////    sort(v.begin(), v.end());
////////    int sum = 0;
////////    for (auto e : v)
////////    {
////////        if (e >= 0)
////////            sum += e;
////////    }
////////    return sum;
////////    return 0;
////////}
//////#include <iostream>
//////#include <string>
//////#include <algorithm>
//////#include <cstring>
//////using namespace std;
//////
////////int main()
////////{
////////    string str1("aba");
////////    string str2("b");
////////    string tmp;
////////    int count = 0;
////////    for (auto e : str1)
////////    {
////////        string a;
////////        tmp += e;
////////        tmp += str2;
////////        reverse(tmp.begin(), tmp.end());
////////        a = tmp;
////////        if (strcmp(tmp.c_str(), a.c_str()) == 0)
////////            count++;
////////        tmp.clear();
////////        tmp += e;
////////    }
////////    cout << count;
////////    return 0;
////////}
//////class A
//////{
//////public:
//////	A(int a)
//////		:_a(a)
//////	{}
//////	operator int()
//////	{
//////		return _a;
//////	}
//////private:
//////	int _a;
//////};
//////int main()
//////{
//////	///*const int i = 0;
//////	//const int* p = &i;
//////	//int* pp = p;*/
//////	A s(10);
//////	cout << sizeof(s) << endl;
//////	int i = static_cast<int>(s);
//////	cout << i;
//////	/*const int i = 0;
//////	const int* p = &i;*/
//////	return 0;
//////}
////#include<iostream>
////using namespace std;
////enum colos
////{
////    RED,
////    BLACK
////};
////template<class T>
////struct rbtnode
////{
////    rbtnode(const T& val)
////        :_val(val)
////    {}
////    T _val = 0;
////    colos _cl = RED;
////    rbtnode<T>* _left = nullptr;
////    rbtnode<T>* _right = nullptr;
////    rbtnode<T>* _parent = nullptr;
////};
////template<class T>
////class rbt
////{
////public:
////    typedef rbtnode<T> node;
////    bool insert(const T& val)
////    {
////        if (_root == nullptr)
////        {
////            _root = new node(val);
////            _root->_cl = BLACK;
////            return true;
////        }
////        // node* parent=cur->_parent;
////        node* cur = _root;
////        node* parent = nullptr;
////        while (cur)
////        {
////            parent = cur;
////            if (cur->_val > val)
////                cur = cur->_left;
////            else if (cur->_val < val)
////                cur = cur->_right;
////            else
////                return false;
////        }
////        cur = new node(val);
////        if (parent->_val < val)
////            parent->_right = cur;
////        else
////            parent->_left = cur;
////        cur->_parent = parent;
////        return true;
////    }
////private:
////    node* _root = nullptr;
////};
////void test1()
////{
////    rbt<int> e;
////    e.insert(1);
////    e.insert(2);
////}
////#include<iostream>
////#include<memory>
////using namespace std;
////int main()
////{
////    //test1();
////    int i = 0;
////    std::shared_ptr<int> p(&i);
////    *p = 10;
////    cout << (*p);
////    
////    return 0;
////}
//class A
//{
//public:
//	A(int a)
//		:_a(a)
//	{}
//	explicit operator int() const
//	{
//		return _a;
//	}
//private:
//	int _a;
//};
//#include<stdio.h>
//#include<stdlib.h>
//#include<iostream>
//int main()
//{
//	//A s(10);
//	////int i = s;
//	//int i = 10;
//	//char l = i;
//	//int i1 = static_cast<int>(s);
//	//int i2 = reinterpret_cast<int>(s);
//	//int t = (int)s;
//	//int* p = (int*)malloc(sizeof(int));
//	//int* pp = reinterpret_cast<int*>(malloc(sizeof(int)));
//	
//		double d = 12.34;
//		int a = static_cast<int>(d);
//		std::cout << a << std::endl;
//		return 0;
//	
//	return 0;
//}
#include<iostream>
#include<string>
#include<stack>
using namespace std;
class Parenthesis {
public:
    bool chkParenthesis(string A, int n)
    {
        // write code here
        stack<char> s;
        for (auto& e : A)
            s.push(e);
        while (!s.empty())
        {
            char ch = s.top();
            s.pop();
            if (ch != '(' && ch != ')')
                return false;
        }
        return true;
    }
};
int main()
{
	string A("(()())");
    bool s=Parenthesis().chkParenthesis(A, 6);
    cout << s << endl;
	return 0;
}
